=====================================SpringMVC 03 ========================================
1 文件上传
2 文件上传的时候的按纽响应问题
3 资源文件的引入
4 ajax 与 json 数据的处理
5 rest 风格
6 ssm 整合-复习mybatis
==========================================================================================
==== 1 文件上传
		1) 配置文件中
		
	    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver" >	      
		     	<property name="defaultEncoding" value="UTF-8" />
		     	<property name="maxUploadSize" value="5400000" />
		     	<property name="uploadTempDir" value="uploadTempDir" />
	     </bean>
			
			上面的三个属性不指定也可以,因为它们有默认值
		
	  2) 上传页面
	  
	      文件上传页面 
	    
	       upload-file.jsp
					<form action="UploadController" method="post" enctype="multipart/form-data">
						<input name="adminName"  >
						<input name="password"  >
						<input name="note"  >
			照片:	<input type="file" name="photo"   >
						<input type="submit" value="提交">
					</form>
	 			
	 			
	 			要注意
	 			 ①  method 必须是post
	 			 ②  enctype="multipart/form-data"
	 			 ③  注意一下,文件上传组件的name ,这里叫 photo ,这个名字在服务端是要用的 
		
		 
		3) 控制层
				@Controller
				public class UploadController {
					@RequestMapping("/upload")
					public String upload(AdminInfo admin ,MultipartFile photo,HttpServletRequest request) throws IllegalStateException, IOException {
						System.out.println(admin);
						System.out.println("photo.getContentType()"  +photo.getContentType());  //image/png
						System.out.println("photo.getName()"  +photo.getName());  //photo 得到的是上传字段的名称
						System.out.println("photo.getOriginalFilename()"  +photo.getOriginalFilename());  //c.jpg
						System.out.println("photo.getSize()"  +photo.getSize());  //1441
				
						String realPath=request.getServletContext().getRealPath("/upload-fiels");
						System.out.println(realPath);
					
						File  destFile=new File(realPath,photo.getOriginalFilename());
						
						photo.transferTo(destFile);
				
						request.setAttribute("msg", "上传成功");
						return "forward:/upload-file.jsp";		
					}
				}

			 可以看到,在springmvc中,文件上传很简单,使用  transferTo 方法就可以了
		

    4) 多文件上传 
				<form action="upload" method="post" enctype="multipart/form-data">
						<input name="adminName"  >
						<input name="password"  >
						<input name="note"  >
						<input type="file" name="photo"   >
						<input type="file" name="photo"   >
						<input type="file" name="photo"   >
						<input type="file" name="photo"   >
				
						<input type="submit" value="提交">
					</form>
							
				@Controller
				public class UploadController {
					@RequestMapping("/upload")
					public String upload(AdminInfo admin ,@RequestParam("photo")  MultipartFile [] photo,HttpServletRequest request) throws IllegalStateException, IOException {
						System.out.println(admin);
						
						for(int i=0;i<photo.length;i++) {
							if(photo[i].getSize()!=0) {	
								System.out.println("photo.getContentType()"  +photo[i].getContentType());  //image/png
								System.out.println("photo.getName()"  +photo[i].getName());  //photo 得到的是上传字段的名称
								System.out.println("photo.getOriginalFilename()"  +photo[i].getOriginalFilename());  //c.jpg
								System.out.println("photo.getSize()"  +photo[i].getSize());  //1441
						
								String realPath=request.getServletContext().getRealPath("/upload-fiels");
								System.out.println(realPath);
							
								File  destFile=new File(realPath,photo[i].getOriginalFilename());
								
								photo[i].transferTo(destFile);
							}
						}
				
						request.setAttribute("msg", "上传成功");
						return "forward:/upload-file.jsp";		
					}
				}
 
				要注意,
				  1) 不要忘了加 @RequestParam("photo") 这个注解,不加将出错
				  2) 不要忘了判断一下 ((photo[i].getSize()!=0 ),没有选择文件,不要做上传动作 
				  3) 要注意,如果不配置虚拟目录,项目重新发布的时候,文件将丢失  //怎么配置虚拟目录,以后再说
				
				
==== 2 文件上传的时候的按纽响应问题

 	   //预览图片  
		  function preview(docObj, localImagId, imgObjPreview, width, height) {
				if (docObj.files && docObj.files[0]) { //火狐下，直接设img属性        
					imgObjPreview.style.display = 'block';
					imgObjPreview.style.width = width;
					imgObjPreview.style.height = height;
					//火狐7以上版本不能用上面的getAsDataURL()方式获取，需要一下方式        
					imgObjPreview.src = window.URL.createObjectURL(docObj.files[0]);
				} else { //IE下，使用滤镜      
					docObj.select();
					var imgSrc = document.selection.createRange().text;
					//必须设置初始大小        
					localImagId.style.width = width;
					localImagId.style.height = height;
					//图片异常的捕捉，防止用户修改后缀来伪造图片        
					try {
						localImagId.style.filter = "progid:DXImageTransform.Microsoft.AlphaImageLoader(sizingMethod=scale)";
						localImagId.filters.item("DXImageTransform.Microsoft.AlphaImageLoader").src = imgSrc;
					} catch (e) {
						alert("您上传的图片格式不正确，请重新选择!");
						return false;
					}
					imgObjPreview.style.display = 'none';
					document.selection.empty();
				}
			}
	 	
	 	
		<form action="upload" method="post" enctype="multipart/form-data">
			<input name="adminName"  >
			<input name="password"  >
			<input name="note"  >
			
			<input type="file" style="display:none" name="photo"  id="file1"  >
	
			<input type="submit" value="提交">
		</form>
		
		<div style="background:silver; width:150px;height:200px"  onclick="document.getElementById('file1').click()">
		    点此上传照片
		</div>
	  	
	  	
==== 3 资源文件的引入
    使用springmvc 以后,我们发现原来的一些静态内容, 比如 html, css, 图片,js 等都访问不到了 
    
    比如我们在 根路径下的 login.jsp中引入图片或css样式,访问某个静态网页,比如 static/welcome.html 
    
    我们要在项目中做静态资源的映射
         <mvc:resources location="/resources/" mapping="/resources/**" />
         
         我们可以将 js,css,images,html等都放到  resources 目录中就可以了
         

         
==== 4 ajax 与 json 数据的处理

		 导包
		 jackson-annotations-2.4.4.jar
		 jackson-core-2.4.4.jar
		 jackson-databind-2.4.4.jar
		 
		 
		 //例一 原始方式 
			<script type="text/javascript">
						$("button").click(function(){
						
							 $.ajax({
								 type:"get",
								 url:"getadmin",
								 dataType:"json",
								 data:{id:5},
								 success:function(data){
									 alert(data.id);
									 alert(data.password);
									 alert(data.note);
								 }
							 });
							
						});	
			</script>
					 
			@Controller
			public class AjaxController {
			
				@RequestMapping("/getadmin")
				public void getAdmin(int id, HttpServletResponse response) throws IOException
				{
					String jsonStr= "{\"id\":\"admin\",\"password\":\"123\",\"note\": \"这是备注\"}" ;	
					System.out.println(jsonStr);
					System.out.println(jsonStr);
					System.out.println(jsonStr);
					System.out.println(jsonStr);
					System.out.println(jsonStr);
				
					response.getWriter().print(jsonStr);
				}
			}


     //例二  springmvc 提供的支持
      
     	@RequestMapping("/getadmin") @ResponseBody
			public AdminInfo getAdmin(int id) throws IOException
			{
				AdminInfo admin=dao.getAdminById(id);	
				return admin;
			}
			
			可以看到,直接 @ReponseBody 注解,就可以将返回的对象直接处理成 json格式的数据
			
			如果服务端接收的数据,是json 格式,可以用 @RequestBody 注解
			
			
			//例三 返回列表 
			@RequestMapping("/getadminlist") @ResponseBody  
			public List<AdminInfo> getAllAdmin()
			{
				List<AdminInfo> adminList=dao.getAllAdmin();
				return adminList;
			}
				  
				  
		 $(function(){ 
				$("button").click(function(){
				
					 $.ajax({
						 type:"get",
						 url:"getadminlist",
						 dataType:"json",
				
						 success:function(adminlist){
							 $.each(adminlist,function(k,admin){
								 var str="<tr><td>"+admin.id+"</td><td>"+admin.adminName+"</td><td>"+admin.password+"</td><tr>";
								 $("#table1").append(str);
							 });
							
						 }
					 });
					
				});
			})	

	
==== 5 restfull 风格

	 REST这个词，是Roy Thomas Fielding在他2000年的博士论文中提出的
			 HTTP协议（1.0版和1.1版）的主要设计者、Apache服务器软件的作者之一、Apache基金会的第一任主席
			 
			 长期以来，软件研究主要关注软件设计的分类、设计方法的演化，很少客观地评估不同的设计选择对系统行为的影响。
			 而相反地，网络研究主要关注系统之间通信行为的细节、如何改进特定通信机制的表现，常常忽视了一个事实，
			 那就是改变应用程序的互动风格比改变互动协议，对整体表现有更大的影响。我这篇文章的写作目的，就是想在符合架构原理的前提下，
			 理解和评估以网络为基础的应用软件的架构设计，得到一个功能强、性能好、适宜通信的架构
			 
			 REST，即 Representational State Transfer的缩写。我对这个词组的翻译是 "表现层状态转化"。  
			 如果一个架构符合REST原则，就称它为 RESTful 架构
			 
			 关于 Representational State Transfer (表现层状态转化) 的理解
			 1)REST的名称"表现层状态转化"中，省略了主语。"表现层"其实指的是"资源"（Resources）的"表现层"。
			 		网络上的一个具体信息,可以用一个URI（统一资源定位符）指向它
       2) Representation 表现层
         "资源"是一种信息实体，它可以有多种外在表现形式。我们把"资源"具体呈现出来的形式，叫做它的"表现层"（Representation）。
         比如，文本可以用txt格式表现，也可以用HTML格式、XML格式
         URI只代表资源的实体，不代表它的形式。严格地说，有些网址最后的".html" 后缀名是不必要的 因为这个后缀名表示格式，属于 "表现层" 
         范畴，而URI应该只代表"资源"的位置。它的具体表现形式，应该在HTTP请求的头信息中用Accept和Content-Type字段指定，
         这两个字段才是对"表现层"的描述。
         
       3) State Transfer 状态转化
					HTTP协议，是一个无状态协议。这意味着，所有的状态都保存在服务器端。因此，如果客户端想要操作服务器，
					必须通过某种手段，让服务器端发生"状态转化"（State Transfer）。而这种转化是建立在表现层之上的，所以就是"表现层状态转化"。
					客户端用到的手段，只能是HTTP协议。具体来说，就是HTTP协议里面，四个表示操作方式的动词：
					  GET、POST、PUT、DELETE。它们分别对应四种基本操作：
					  GET用来获取资源，POST用来新建资源（也可以用于更新资源），PUT用来更新资源，DELETE用来删除资源。
					  
	
			综合上面的解释，我们总结一下什么是RESTful架构：

	　　（1）每一个URI代表一种资源；
	
	　　（2）客户端和服务器之间，传递这种资源的某种表现层；
	
	　　（3）客户端通过四个HTTP动词，对服务器端资源进行操作，实现"表现层状态转化"
	
	
	    查看一个用户的信息
	     http://localhost:8080/myweb/UserServlet ? flag= delete & id=8
	     
	     rest  风格 ==>
	     http://localhost:8080/myweb/UserServlet/8
	     
	     http://www.douban.com/photos/album/49432287/  这是豆瓣网上的
	     
	     http://localhost:8080/myweb/user/delete/5
	     
	     在springmvc  中实现 rest 风格 

	     //非rest风格 :按用户名和密码查询一个用户
			
		   	@RequestMapping("/login")
			  public String login(String adminName,String password)  {
						System.out.println(adminName);
						System.out.println(password);
						.....
			  }
			  
			  http://localhost:8080/springmvc-01/login?adminName=123&password=aaaa
		    
	   
			 //rest风格  
			 	@RequestMapping("/login/{a}/{b}")
			  public String login(@PathVariable("a" ) String adminName,@PathVariable("b") String password)  {
						System.out.println(adminName);
						System.out.println(password);
						.....
			  }
			   
			  http://localhost:8080/springmvc-01/login/admin/123
			  
			  
			  //例
				@Controller
				public class RestAdminCountroller {
					
					@RequestMapping(value="/admin" ,method=RequestMethod.POST)
					String add() {
						return "xxx";
					}
					
					@RequestMapping(value="/admin",method=RequestMethod.DELETE)
					String delete() {
						return "xxx";
					}
					
					@RequestMapping(value="/admin",method=RequestMethod.PUT)
					String update() {
						return "xxx";
					}
					
					@RequestMapping(value="/admin",method=RequestMethod.GET)
					String getUser() {
						return "xxx";
					}
				}
				

==== 6 ssm 整合-复习mybatis
			spring  springmvc mybatis 
		
		1) 导包
			 springmvc 相关的包
			 spring相关的包
			 mybatis相关的
			 spring和mybatis整合的
			 
	  2) 新建一个源文件夹,叫config 和 src平级, 
	     里面再放两个目录
	        mybatis
	        spring 
	        
	  3) 在config 下,建 dbconfig.properties 属性文件
						db.driver=com.mysql.cj.jdbc.Driver
						db.url=jdbc:mysql://localhost:3306/shop?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC
						db.username=root
						db.password=root

	
	  4) 建 mybatis 的主配置文件 mybatis-config.xml  放在 config/mybatis/ 下
				<?xml version="1.0" encoding="UTF-8"?>  
				<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
				"http://mybatis.org/dtd/mybatis-3-config.dtd">  
				<configuration>  
					<properties resource="dbconfig.properties" /> 
					
					<typeAliases> 
						<package name="com.beans" />  
					</typeAliases>		
					
				    <environments default="development">    
				       <environment id="development">  
				           <transactionManager type="JDBC"/>  
				           <dataSource type="POOLED">  
				               <property name="driver" value="${db.driver}"/>  
				               <property name="url" value="${db.url}"/>  
				               <property name="username" value="${db.username}"/>  
				               <property name="password" value="${db.password}"/>  
				           </dataSource>  
				       </environment>  
				    </environments>  
				    
				    <mappers>
						<mapper resource="mybatis/mappings/UserInfo.xml" /> 
					</mappers>
				</configuration>
				
	 5)  创建  UserInfo 实体类和    UserInfo.xml 
	 
	      这个文件,放在 config/mybatis/mappings/
				<?xml version="1.0" encoding="UTF-8" ?>  
				<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
				"http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
				<mapper namespace="user">  
				   <select id="getuser_byid" parameterType="int"  resultType="userInfo" >
				   		 select * from userInfo where id=#{id}
				   </select>
				   
				   <insert id="add_user" parameterType="userInfo" >
				   		insert into userInfo (userName,password,note) values (#{userName},#{password},#{note})
				   </insert>
				   
				   <update id="update_user" parameterType="userInfo">
				   		update userInfo set userName= #{userName}, password=#{password}, note =#{note} where id=#{id} 
				   </update>
				   
				   <delete id="delete_user" parameterType="int" >
				   		delete from userInfo where id=#{id} 
				   </delete>
				  
				</mapper>
				
		6) 测试
				public class Test {
				
					public static void main(String[] args) throws IOException {
						InputStream in=Resources.getResourceAsStream("mybatis/mybatis-config.xml");
						SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);
						SqlSession session =factory.openSession();
						
						UserInfo user= session.selectOne("user.getuser_byid",1);  //注意,前面的 user. 是namespace的名字
						System.out.println(user);
						
						//其他方法就不测试了
						
						session.commit();
						session.close();
					}
				
				}
								
								
		7) 创建 dao层 
		    接口
				public interface IUserDao {
					 int addUser(UserInfo user);   //也可以声明为void
					 
					 UserInfo getUserById(int id);
					 
					 void delUser(int id);  //也可以声明为int 
					 
					 int updateUser(UserInfo user);
				}
				
				实现类
				public class UserDaoImpl implements IUserDao{
					SqlSessionFactory sqlSessionFactory; 
					
					public UserDaoImpl(SqlSessionFactory sqlSessionFactory){
						this.sqlSessionFactory=sqlSessionFactory;
					}
					
					public int addUser(UserInfo user) {
						SqlSession  session=sqlSessionFactory.openSession();
						int result=session.insert("user.add_user",user);
						session.commit();
						session.close();
						return result;
					}
				
					public UserInfo getUserById(int id) {
						SqlSession  session=sqlSessionFactory.openSession();
						UserInfo user = session.selectOne("user.getuser_byid",id);
						session.close();
						return user;
					}
				
					public void delUser(int id) {
						SqlSession  session=sqlSessionFactory.openSession();
						session.delete("user.delete_user",id);
						session.commit();
						session.close();
					}
				
					public int updateUser(UserInfo user) {
						SqlSession  session=sqlSessionFactory.openSession();
						int result=session.update("user.update_user",user);
						session.commit();
						session.close();
						return result;
					}
				}
				
				测试dao层
				public class TestDao {
				
					public static void main(String[] args) throws IOException {
						InputStream in=Resources.getResourceAsStream("mybatis/mybatis-config.xml");
						SqlSessionFactory factory=new SqlSessionFactoryBuilder().build(in);
					
						IUserDao dao=new UserDaoImpl(factory);
						
						/*测试查询
						UserInfo user=dao.getUserById(1);
						System.out.println(user); */
						
						
						/*测试修改
						user.setUserName("赵明明明明");
						user.setPassword("xxxxxx");
						int n=dao.updateUser(user);
						System.out.println(n==1?"修改成功":"修改失败"); */
						
						/*测试添加
						UserInfo user=new UserInfo();
						user.setUserName("root");
						user.setPassword("root133");
						user.setNote("这是root");
						int n=dao.addUser(user);
						System.out.println(n==1?"添加成功":"添加失败");  */
						
						
						//测试删除 
						dao.delUser(2);
						System.out.println("删除成功");
					}
				}
				
==== 3  ssm 整合-mybatis 和 spring 整合
		
		 1) 加入spring环境   在 config/spring/ 下建 beans.xml 
		 
				<?xml version="1.0" encoding="UTF-8"?>
				<beans xmlns="http://www.springframework.org/schema/beans"
					xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
					xmlns:context="http://www.springframework.org/schema/context"
					xmlns:aop="http://www.springframework.org/schema/aop"
					xmlns:tx="http://www.springframework.org/schema/tx"
					xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
						http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
						http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
						http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd">
				
					<!-- 以自动扫描的方式把组件纳入spring管理 -->
					<context:component-scan base-package="com" />
					
					<!-- 配置数据源 -->
					<context:property-placeholder location="classpath:dbconfig.properties"/>
				    <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
					     <property name="driverClassName" value="${db.driver}"/>
					     <property name="url" value="${db.url}"/>
					     <property name="username" value="${db.username}"/>
					     <property name="password" value="${db.password}"/>
							 <property name="initialSize" value="10"/> 
							 <property name="maxActive" value="500"/>	
							 <property name="maxIdle" value="2"/>      
							 <property name="minIdle" value="3"/>	 
				    </bean>
				    			
					<!-- 配置SqlSessionFactory --> 
				   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
						 <property name="dataSource" ref="dataSource" />
						 <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />   
						 <property name="mapperLocations" value="classpath:mybatis/mappings/*.xml" />	
					</bean>
					
					<!-- 配置事务 -->
				   <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
				 	 		<property name="dataSource" ref="dataSource"/>
				   </bean>
				   
				   <aop:config>
				  	  <aop:pointcut id="myTxPointCut"  expression="execution(* com.dao.UserDaoImpl.*(..))" />  
					 	  <aop:advisor advice-ref="txAdvisor" pointcut-ref="myTxPointCut"/> 
				   </aop:config>
				   
				   <tx:advice id="txAdvisor" transaction-manager="txManager">
					 <tx:attributes>
							<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
							<tx:method name="*"  />
				    </tx:attributes>
				   </tx:advice>
				    
				</beans>
					
					
		   做完上面的配置之后 mybatis的主配置文件 mybatis-config.xml 中的一些内容就不需要了,最后只留下:
		
				<?xml version="1.0" encoding="UTF-8"?>  
				<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"  
				"http://mybatis.org/dtd/mybatis-3-config.dtd">  
				<configuration>  
					<typeAliases> 
						<package name="com.beans" />  
					</typeAliases>		
				</configuration>

			
		2) 将dao层交给Spring管理
					@Repository
					public class UserDaoImpl implements IUserDao{
						@Resource
						SqlSessionFactory sqlSessionFactory;   //让spring帮我们自动注入这个factory
						
						....				
					}
					
	  3) 测试
				public class TestDao {
				
					public static void main(String[] args) throws IOException {
						ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("spring/beans.xml");
						IUserDao dao=ctx.getBean("userDaoImpl" ,IUserDao.class);
						
						//查询
						UserInfo user=dao.getUserById(1);
						System.out.println(user);
						
						//修改
						user.setUserName("administrator");
						dao.updateUser(user);
						
						//添加
						UserInfo u=new UserInfo();
						u.setUserName("scott");
						u.setPassword("pwdaaaa");
						dao.addUser(u);
						
						//删除
						dao.delUser(3);
						System.out.println("----ok-----");
						
						ctx.close();
					}
				}
				
				
==== 4 ssm 整合 mybatis +spring +springmvc
    新建springmvc环境
    
    1)springmvc的主配置文件 springmvc-config.xml 放在 config/spring/ 下
    
			<?xml version="1.0" encoding="UTF-8"?>
			<beans xmlns="http://www.springframework.org/schema/beans"
				xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
				xmlns:context="http://www.springframework.org/schema/context"
				xmlns:mvc="http://www.springframework.org/schema/mvc"
				xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
					http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
					http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
			
				<!-- 开启扫描 -->
				<context:component-scan base-package="com.controller"  />
				
				<!-- 开启注解驱动 -->
				<mvc:annotation-driven />
				
				<!-- 视图解析器 -->
				<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
					<property name="prefix" value="/" />
					<property name="suffix" value=".jsp" />
				</bean>
			
				<!--静态资源映射 -->
				<mvc:resources location="/resources/" mapping="/resources/**" />
			</beans>
					
	 2) web.xml 
	     (1) 初始化spring容器
					  <context-param>
								<param-name>contextConfigLocation</param-name>
								<param-value>classpath:spring/beans.xml</param-value>
					  </context-param>
					  <listener>
								<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
					  </listener>
	  
	     (2) 初始化springmvc , 把所有的请求,交给springmvc 流程
					   <servlet>
							<servlet-name>springmvc</servlet-name>
							<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
							<init-param>
								<param-name>contextConfigLocation</param-name>
								<param-value>classpath:spring/springmvc-config.xml</param-value>
							</init-param>
							<load-on-startup>1</load-on-startup>
						</servlet>
								
						<servlet-mapping>
							<servlet-name>springmvc</servlet-name>
							<url-pattern>/</url-pattern>
						</servlet-mapping>
	      
	  3) 控制层 先来一个简单的测试
					@Controller
					public class UserController {
						@RequestMapping("/getuser/{id}")
						public String getUser(@PathVariable("id")  int id, ModelMap m) {
							m.put("msg", "用户查询成功..ssm 大功千成 ... 哈哈哈");
							return "main"; 
						}	
					}
					
	     然后在浏览器地址栏进行测试 http://localhost:8080/spring-mybatis/getuser/1
	     
	  4) 添加对 dao 层的依赖 
				@Controller
				public class UserController {
					
					@Resource(name="userDaoImpl")
					IUserDao dao;
					
					@RequestMapping("/getuser/{id}")
					public String getUser(@PathVariable("id")  int id, ModelMap m) {
						UserInfo user =dao.getUserById(id);
						m.put("msg", "用户查询成功..ssm 大功千成 ... 哈哈哈");
						m.put("user",user);
						return "main"; 
					}	
					
					@ResponseBody  @RequestMapping("/get_user/{id}")
					public UserInfo getUserJson(@PathVariable("id")  int id, ModelMap m) {
						UserInfo user =dao.getUserById(id);
						return user;
					}	
				}
				
				
				在main.jsp 上
			    <h1> 大功告成 </h1> 		    
			    ${msg } <br />
			    
			    ${user.id }  <br />
			    ${user.userName } <br /> 
			    ${user.password } <br />
			    ${user.note }
	    
				
==== 5 ssm 整合 mapper 代理的方式
		1) 把原来的 dao删除 ,在工程中建一个包 mapper 
		   在里面建一个接口 UserMapper ,相当于过去的 UserDao
		   
		   这个接口中的方法名和映射文件中的sql的id相同,返回值类型和 sql resultType匹配,参数类型和 sql 的 parameterType 匹配
		   
				public interface UserMapper {
					UserInfo getuser_byid(int id);
					int add_user(UserInfo user);
					int update_user(UserInfo user);
					int delete_user(int id);
				}
						
		2) 建立UserMapper.xml  这个映射文件, 这里采取映射文件和接口放在同一个目录下的方案   
		
		        === com/mapper/UserMapper.xml ===
		          
					<?xml version="1.0" encoding="UTF-8" ?>  
					<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
					"http://mybatis.org/dtd/mybatis-3-mapper.dtd">  
					<mapper namespace="com.mapper.UserMapper">   //一定要注意namespace 必须写成接口的全名称
					 
					   <select id="getuser_byid" parameterType="int"  resultType="userInfo" >
					   		 select * from userInfo where id=#{id}
					   </select>
					   
					   <insert id="add_user" parameterType="userInfo" >
					   		insert into userInfo (userName,password,note) values (#{userName},#{password},#{note})
					   </insert>
					   
					   <update id="update_user" parameterType="userInfo">
					   		update userInfo set userName= #{userName}, password=#{password}, note =#{note} where id=#{id} 
					   </update>
					   
					   <delete id="delete_user" parameterType="int" >
					   		delete from userInfo where id=#{id} 
					   </delete>
					  
					</mapper>			
					
					附:就不用保留  config/mybatis/mapping 目录了,删了它就可以了			
					
		3) srping 的主配置文件			
					<!-- 配置SqlSessionFactory --> 
				    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
						 <property name="dataSource" ref="dataSource" />
						 <property name="configLocation" value="classpath:mybatis/mybatis-config.xml" />   
						 <!-- 用mapper代理的方式,这句就不用了
						 <property name="mapperLocations" value="classpath:mybatis/mapping/*.xml" />	
						  -->
					</bean>
					
					<!-- 再添加这个bean,用于扫描mapper映射文件所在的包,装载这些映射文件 -->
					 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
						 <property name="basePackage" value="com.mapper" />  
						 <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />   
					 </bean>
					 
					还有,就是用mapper代理的方式,由于我们没有dao层的实现类,所以原来的事务相关的配置暂时就不要了
					
						<!-- 下面的内容不要了
						   <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
						 	 	<property name="dataSource" ref="dataSource"/>
						   </bean>
						   
						   <aop:config>
						  	  <aop:pointcut id="myTxPointCut"  expression="execution(* com.dao.impl.UserDaoImpl.*(..))" />  
							  <aop:advisor advice-ref="txAdvisor" pointcut-ref="myTxPointCut"/> 
						   </aop:config>
						   
						   <tx:advice id="txAdvisor" transaction-manager="txManager">
							<tx:attributes>
								<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
								<tx:method name="*"  />
						    </tx:attributes>
						   </tx:advice>
						  -->
												
		3) 控制层

				@Controller
				public class UserController {
					
					@Resource
					UserMapper useMapper;
					
					@RequestMapping("/getuser/{id}")
					public String getUser(@PathVariable("id")  int id, ModelMap m) {
						UserInfo user =useMapper.getuser_byid(id);
						m.put("msg", "用户查询成功..ssm..mppper 方式大功告成 ... 哈哈哈");
						m.put("user",user);
						return "main"; 
					}	
					
					@ResponseBody  @RequestMapping("/get_user/{id}")
					public UserInfo getUserJson(@PathVariable("id")  int id, ModelMap m) {
						UserInfo user =useMapper.getuser_byid(id);
						return user;
					}	
				}
				
				
			在浏览器地址栏访问		
			  http://localhost:8080/ssm-mapper-demo/getuser/1
					
					
			附: 用main 函数进行测试
				public class TestMapper {
					public static void main(String[] args) throws IOException {
						ClassPathXmlApplicationContext ctx=new ClassPathXmlApplicationContext("spring/beans.xml");
						UserMapper dao=ctx.getBean("userMapper" ,UserMapper.class);
						
						//查询
						UserInfo user=dao.getuser_byid(1);
						System.out.println(user);
						
						//修改
						user.setUserName("administrator");
						dao.update_user(user);
						
						//添加
						UserInfo u=new UserInfo();
						u.setUserName("scott");
						u.setPassword("pwdaaaa");
						dao.add_user(u);
						
						//删除
						dao.delete_user(3);
						System.out.println("----ok-----");
						
						ctx.close();
					}
				}
																																				  					  
									
==== 6 关于业务层和事务处理

  1) 声明业务层接口
		public interface IUserService {
			//查询用户信息
			void getUserInfo(int id);
			
			//用户入职
			void ruZhi(UserInfo user);
		}
		
	2) 业务层的实现类
			@Service
			public class UserServiceImpl implements IUserService{
			
				@Resource
				UserMapper mapper;
			
				public UserInfo getUserInfo(int id) {	
					System.out.println("------业务经理新自出马 ------");
					return mapper.getuser_byid(id);
				}
			
				public void ruZhi(UserInfo user) {
					System.out.println("------业务经理开始办理员工入职 ------");
					mapper.add_user(user);
					System.out.println("------业务经理办理结束 ------");
				}
			}
  
  3) 控制层 
			@Controller
			public class UserController {
				
				@Resource
				IUserService userService;
				
				@RequestMapping("/getuser/{id}")
				public String getUser(@PathVariable("id")  int id, ModelMap m) {
					UserInfo user =userService.getUserInfo(id);
					m.put("msg", "用户查询成功..ssm..mppper 方式大功告成 ... 哈哈哈");
					m.put("user",user);
					return "main"; 
				}	
				
				@ResponseBody  @RequestMapping("/get_user/{id}")
				public UserInfo getUserJson(@PathVariable("id")  int id, ModelMap m) {
					UserInfo user =userService.getUserInfo(id);
					return user;
				}	
				
				//入职
				@RequestMapping(value ="/ruzhi", method=RequestMethod.POST)
				public String ruzhi(UserInfo user, ModelMap m) {
					userService.ruZhi(user);
					m.put("user", user);
					return "main"; 
				}
			}

							
			user_add.jsp 															  
	    	<form action="ruzhi" method="post">
	    		<input name="userName"  >
	    		<input name="password"  >
	    		<input name="note"  >
	    		<input type="submit" value="入职" >
	    	</form>												 
								 
								 
   --------------------测试 略 ---------------------------
   -----------------------------------------------------------
   事务管理
		   
		   
		业务接口中添一个方法
			public interface IUserService {
					//查询用户信息
					UserInfo getUserInfo(int id);
					
					//用户入职
					void ruZhi(UserInfo user);
					
					/**
					 * 把一个员工开除,换一个新员工
					 * @param id 要被删除的员工的id
					 * @param user 要添加的员工的新信息
					 */
					void change(int id ,UserInfo user);
			}

		
		实现类				
				@Service
				public class UserServiceImpl implements IUserService{
				
					@Resource
					UserMapper mapper;
				
					public UserInfo getUserInfo(int id) {	
						System.out.println("------业务经理新自出马 ------");
						return mapper.getuser_byid(id);
					}
				
					public void ruZhi(UserInfo user) {
						System.out.println("------业务经理开始办理员工入职 ------");
						mapper.add_user(user);
						System.out.println("------业务经理办理结束 ------");
					}
				
					
					//本方法用于演示事务
					public void change(int id, UserInfo user) {
						System.out.println("业务经理开始折腾");
						
						//先开除老员工
						mapper.delete_user(id);
						
						System.out.println("我今天心情很美丽...嘻嘻哈哈 ");
						int x=9/0;
						
						//再给新人办入职
						mapper.add_user(user);	
						
						System.out.println("业务经理开始折腾结束");		
					}
				}
				
							
			@Controller
			public class UserController {
				
				@Resource
				IUserService userService;  //多数系统,控制层都是依赖于业务层,而不是直接依赖于数据访问层
				
				@RequestMapping("/getuser/{id}")
				public String getUser(@PathVariable("id")  int id, ModelMap m) {
					UserInfo user =userService.getUserInfo(id);
					m.put("msg", "用户查询成功..ssm..mppper 方式大功告成 ... 哈哈哈");
					m.put("user",user);
					return "main"; 
				}	
				
				@ResponseBody  @RequestMapping("/get_user/{id}")
				public UserInfo getUserJson(@PathVariable("id")  int id, ModelMap m) {
					UserInfo user =userService.getUserInfo(id);
					return user;
				}	
				
				@RequestMapping(value ="/ruzhi", method=RequestMethod.POST)
				public String ruzhi(UserInfo user, ModelMap m) {
					userService.ruZhi(user);
					m.put("user", user);
					return "main"; 
				}
				
				@RequestMapping("change")
				public String change(int oldId,UserInfo user, ModelMap m) {
					System.out.println("被删除的人是:"+oldId);
					userService.change(oldId, user);
					
					m.put("user", user);
					m.put("msg", "老员工开除成功,新员工信息如下:");
					return "main";
				}
			}
			
	
		事务的配置要加上 
 
	   <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> 
	 	 	<property name="dataSource" ref="dataSource"/>
	   </bean>
	   
	   <aop:config>
	  	  <aop:pointcut id="myTxPointCut"  expression="execution(* com.service.impl.UserServiceImpl.*(..))" />  //事务要配置在业务层上
		  <aop:advisor advice-ref="txAdvisor" pointcut-ref="myTxPointCut"/> 
	   </aop:config>
	   
	   <tx:advice id="txAdvisor" transaction-manager="txManager">
		 <tx:attributes>
			<tx:method name="get*" read-only="true" propagation="NOT_SUPPORTED"/>
			<tx:method name="*" propagation="REQUIRED"  />
	    </tx:attributes>
	   </tx:advice>

	 user_add.jsp 
	 
	    	<form action="change" method="post">
	    	要删除的老员工id :<input name="oldId" >   <br />
	    		新员工名称:<input name="userName"  >  <br />
	    		新员工密码:<input name="password"  >  <br />
	    		新员工备注:<input name="note"  > <br />
	    		<input type="submit" value="入职" >
	    	</form>
	          
	    运行程序,进行测试,发现开启事务以后,确实业务层的代码受到了事务管理
	          
	          
	          
	          
	         
	       
	  
    
   